package com.blrs.service.member.impl;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.Date;

import com.blrs.common.core.domain.AjaxResult;
import com.blrs.common.core.domain.TreeSelect;
import com.blrs.common.core.domain.entity.SysDictData;
import com.blrs.common.utils.SecurityUtils;
import com.blrs.domain.MemberTemplate;
import com.blrs.mapper.MemberTemplateMapper;
import com.blrs.service.member.IMemberTemplateService;
import com.blrs.system.mapper.SysDictDataMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


/**
 * 【请填写功能名称】Service业务层处理
 *
 * @author ruoyi
 * @date 2025-01-03
 */
@Service
public class MemberTemplateServiceImpl implements IMemberTemplateService {
    @Autowired
    private MemberTemplateMapper memberTemplateMapper;

    @Autowired
    private SysDictDataMapper sysDictDataMapper;

    /**
     * 查询【请填写功能名称】
     *
     * @param id 【请填写功能名称】主键
     * @return 【请填写功能名称】
     */
    @Override
    public MemberTemplate selectMemberTemplateById(String id) {
        return memberTemplateMapper.selectMemberTemplateById(id);
    }

    /**
     * 查询【请填写功能名称】列表
     *
     * @param memberTemplate 【请填写功能名称】
     * @return 【请填写功能名称】
     */
    @Override
    public List<MemberTemplate> selectMemberTemplateList(MemberTemplate memberTemplate) {
        memberTemplate.setBelongTo(SecurityUtils.getOrgId());
        return memberTemplateMapper.selectMemberTemplateList(memberTemplate);
    }

    /**
     * 新增【请填写功能名称】
     *
     * @param memberTemplate 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int insertMemberTemplate(MemberTemplate memberTemplate) {
        memberTemplate.setDelFlag("0");
        return memberTemplateMapper.insertMemberTemplate(memberTemplate);
    }

    /**
     * 修改【请填写功能名称】
     *
     * @param memberTemplate 【请填写功能名称】
     * @return 结果
     */
    @Override
    public int updateMemberTemplate(MemberTemplate memberTemplate) {
        return memberTemplateMapper.updateMemberTemplate(memberTemplate);
    }

    /**
     * 批量删除【请填写功能名称】
     *
     * @param ids 需要删除的【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteMemberTemplateByIds(String[] ids) {
        return memberTemplateMapper.deleteMemberTemplateByIds(ids);
    }

    /**
     * 删除【请填写功能名称】信息
     *
     * @param id 【请填写功能名称】主键
     * @return 结果
     */
    @Override
    public int deleteMemberTemplateById(String id) {
        return memberTemplateMapper.deleteMemberTemplateById(id);
    }

    @Override
    public AjaxResult selectQualificationByType() {
        List<SysDictData> list = sysDictDataMapper.selectDictDataByType("product_type");
        ArrayList<TreeSelect> treeSelects = new ArrayList<>();
        for (SysDictData sysDictData : list) {
            TreeSelect treeSelect = new TreeSelect();
            treeSelect.setLabel(sysDictData.getDictLabel());
            treeSelect.setTreeId(sysDictData.getDictValue());
            treeSelects.add(treeSelect);
        }
        //先创建一个父节点
        ArrayList<TreeSelect> treeSelects1 = new ArrayList<>();
        TreeSelect parentTree = new TreeSelect();
        parentTree.setTreeId("0");
        parentTree.setChildren(treeSelects);
        parentTree.setLabel("产品类别");
        treeSelects1.add(parentTree);
        return AjaxResult.success(treeSelects1);
    }

    @Override
    public AjaxResult batchInsertMemberTemplate(String typeId, List<Map<String, Object>> memberList) {
        try {
            // 1. 获取该类型下的所有数据（包括已删除的）
            MemberTemplate queryTemplate = new MemberTemplate();
            queryTemplate.setTypeId(typeId);
            queryTemplate.setBelongTo(SecurityUtils.getOrgId());
            // 注意：这里需要修改 mapper 方法，使其能够查询所有数据，包括已删除的
            List<MemberTemplate> allExistingTemplates = memberTemplateMapper.selectAllMemberTemplateList(queryTemplate);
            // 2. 将新数据转换为MemberTemplate对象
            List<MemberTemplate> newTemplates = new ArrayList<>();
            for (Map<String, Object> member : memberList) {
                MemberTemplate template = new MemberTemplate();
                template.setId(UUID.randomUUID().toString());
                template.setTypeId(typeId);
                // 处理userId类型转换
                Object userIdObj = member.get("userId");
                if (userIdObj != null) {
                    if (userIdObj instanceof Integer) {
                        template.setUserId(((Integer) userIdObj).longValue());
                    } else if (userIdObj instanceof Long) {
                        template.setUserId((Long) userIdObj);
                    } else if (userIdObj instanceof String) {
                        template.setUserId(Long.parseLong((String) userIdObj));
                    }
                }
                template.setUserName((String) member.get("userName"));
                template.setContact((String) member.get("contact"));
                template.setPosition((String) member.get("position"));
                template.setBelongTo(SecurityUtils.getOrgId());
                template.setDelFlag("0");
                template.setCreationId(SecurityUtils.getUserId());
                template.setCreationName(SecurityUtils.getUsername());
                template.setCreationTime(new Timestamp(new Date().getTime()));
                newTemplates.add(template);
            }
            // 3. 处理需要删除和恢复的记录
            List<String> idsToDelete = new ArrayList<>();
            List<String> idsToRecover = new ArrayList<>();
            List<MemberTemplate> templatesToAdd = new ArrayList<>();
            // 遍历现有数据（包括已删除的）
            for (MemberTemplate existing : allExistingTemplates) {
                boolean found = false;
                for (MemberTemplate newTemplate : newTemplates) {
                    if (existing.getUserId().equals(newTemplate.getUserId())
                            && existing.getUserName().equals(newTemplate.getUserName())) {
                        found = true;
                        // 如果找到匹配项，且原记录是已删除状态，需要恢复
                        if ("1".equals(existing.getDelFlag())) {
                            idsToRecover.add(existing.getId());
                        }
                        // 从新模板列表中移除已匹配的项
                        newTemplates.remove(newTemplate);
                        break;
                    }
                }
                // 如果在新数据中未找到，且原记录未删除，则需要删除
                if (!found && "0".equals(existing.getDelFlag())) {
                    idsToDelete.add(existing.getId());
                }
            }

            // 剩余的新模板都是需要新增的
            templatesToAdd.addAll(newTemplates);
            // 4. 执行删除操作
            if (!idsToDelete.isEmpty()) {
                memberTemplateMapper.deleteMemberTemplateByIds(idsToDelete.toArray(new String[0]));
            }
            // 5. 执行恢复操作
            if (!idsToRecover.isEmpty()) {
                memberTemplateMapper.recoverMemberTemplateByIds(idsToRecover.toArray(new String[0]));
            }
            // 6. 执行新增操作
            if (!templatesToAdd.isEmpty()) {
                int rows = memberTemplateMapper.batchInsertMemberTemplate(templatesToAdd);
                if (rows <= 0) {
                    return AjaxResult.error("批量新增失败");
                }
            }
            return AjaxResult.success("操作成功");
        } catch (Exception e) {
            return AjaxResult.error("批量更新异常：" + e.getMessage());
        }
    }
}
